import { uploadErrorLog } from '../api/error-logger';
import { createDefaultQueue } from './queue-interface';
import { env } from './env';

/**
 * 错误日志收集器
 * 特性：
 * 1. 队列处理，减少并发请求压力
 * 2. 批量上传，减少网络请求次数
 * 3. 去重处理，避免重复错误大量上报
 * 4. 限流处理，控制上报频率
 * 5. 失败重试，提高上报成功率
 * 6. 用户活动感知，避免在用户操作时上传
 * 7. 网络状态感知，优先在良好网络环境上传
 * 8. 智能调度，使用空闲时间处理日志
 * 9. 接口故障检测，自动切换到本地存储模式
 * @author [wurenlong]
 */
class ErrorLogger {
  /**
   * 创建错误日志收集器
   * @param {Object} config 配置项
   * @param {Object} queueInstance 自定义队列实例，必须实现QueueInterface接口
   */
  constructor(config = {}, queueInstance = null) {
    // 合并默认配置
    this.config = Object.assign({
      maxLogCount: 100,           // 最大日志缓存数量
      flushInterval: 60000,       // 日志上传间隔 (ms)
      batchSize: 10,              // 批量上传数量
      maxRetries: 3,              // 最大重试次数
      retryDelay: 5000,           // 重试延迟 (ms)
      rateLimit: {
        enabled: true,            // 是否启用频率限制
        timeWindow: 60000,        // 时间窗口 (ms)
        maxOccurrences: 5,        // 最大出现次数
      }
    }, config);

    // 初始化队列
    this.queue = queueInstance;
    this.queueReady = !!queueInstance; // 标记队列是否就绪
    this.pendingInitQueue = false;     // 标记是否正在初始化队列
    
    this.logCache = [];           // 日志缓存
    this.isConnected = true;      // 网络连接状态
    this.isUploading = false;     // 上传状态
    this.retryCount = 0;          // 重试计数
    this.sessionLogCount = 0;     // 会话日志计数
    this.lastActiveTime = Date.now(); // 最后活跃时间
    this.rateTracking = {};       // 频率限制追踪
    this.apiFailureState = {
      isFailure: false,
      consecutiveFailures: 0,
      lastFailureTime: 0,
      backoffInterval: 5000,
      maxBackoffInterval: 1800000,
      nextRetryTime: 0
    }; // API可用状态
    this.apiFailureTime = 0;      // API失败时间
    
    // 用于限流
    this.logTimestamps = [];
    
    // 存储键
    this.storageKeys = {
      logs: 'error_logger_cached_logs',
      state: 'error_logger_state'
    };
    
    // 设备和应用信息
    this.deviceInfo = this._collectDeviceInfo();
    this.appInfo = this._collectAppInfo();

    // 初始化计时器
    this.timers = {
      flush: null,
      networkCheck: null,
      memoryMonitor: null,
      cleanup: null,
      storageCheck: null
    };

    // 应用状态
    this.appState = {
      inBackground: false,
      lastStateChange: Date.now(),
    };

    // 初始化系统
    if (!queueInstance) {
      this.pendingInitQueue = true;
      this._initQueueAsync().catch(e => {
        console.error('[ErrorLogger] 队列异步初始化失败:', e);
        this._createFallbackQueue();
        this.queueReady = true;
        this.pendingInitQueue = false;
        this._init();
      });
    } else {
      this._init();
    }
  }
  
  /**
   * 异步初始化队列
   * @private
   */
  async _initQueueAsync() {
    try {
      this.queue = await createDefaultQueue();
      console.log('[ErrorLogger] 默认队列初始化完成');
      
      // 标记队列已就绪
      this.queueReady = true;
      this.pendingInitQueue = false;
      
      // 队列就绪后，处理已缓存的日志
      this._processPendingLogs();
      
      // 初始化其他组件
      this._init();
    } catch (error) {
      console.error('[ErrorLogger] 队列初始化失败:', error);
      // 创建一个简单的内存队列作为备用
      this._createFallbackQueue();
      
      // 标记队列已就绪
      this.queueReady = true;
      this.pendingInitQueue = false;
      
      // 处理已缓存的日志
      this._processPendingLogs();
      
      // 初始化其他组件
      this._init();
    }
  }
  
  /**
   * 处理队列初始化前缓存的日志
   * @private
   */
  _processPendingLogs() {
    if (this.logCache.length > 0) {
      console.log(`[ErrorLogger] 处理队列初始化前缓存的 ${this.logCache.length} 条日志`);
      
      // 为每条日志创建上传任务
      this.logCache.forEach(log => {
        const uploadTask = () => {
          return this._uploadLogs([log]);
        };
        
        try {
          this.queue.addTask(uploadTask, {}, {
            onError: (ctx) => {
              console.error('[ErrorLogger] 处理缓存日志任务失败:', ctx);
            }
          });
        } catch (e) {
          console.error('[ErrorLogger] 添加缓存日志到队列失败:', e);
        }
      });
      
      // 启动队列处理
      if (!this.queue.locked && this.logCache.length > 0) {
        try {
          this.queue.start();
        } catch (e) {
          console.error('[ErrorLogger] 启动队列处理缓存日志失败:', e);
        }
      }
    }
  }
  
  /**
   * 创建备用队列
   * @private
   */
  _createFallbackQueue() {
    console.warn('[ErrorLogger] 使用备用队列');
    
    this.queue = {
      locked: false,
      tasks: [],
      callbacks: [],
      
      addTask(task, params, hooks) {
        const promise = new Promise((resolve, reject) => {
          this.tasks.push({
            task,
            params,
            hooks,
            resolve,
            reject
          });
        });
        return promise;
      },
      
      isEmpty() {
        return this.tasks.length === 0;
      },
      
      size() {
        return this.tasks.length;
      },
      
      lock() {
        this.locked = true;
      },
      
      start() {
        if (this.isEmpty() || this.locked) return;
        
        this.locked = true;
        this._processNext();
      },
      
      _processNext() {
        if (this.isEmpty()) {
          this.locked = false;
          this._executeCallbacks();
          return;
        }
        
        const taskItem = this.tasks.shift();
        
        if (taskItem.hooks && typeof taskItem.hooks.beforeStart === 'function') {
          taskItem.hooks.beforeStart(taskItem);
        }
        
        Promise.resolve()
          .then(() => taskItem.task(taskItem.params))
          .then(result => {
            if (taskItem.hooks && typeof taskItem.hooks.beforeEnd === 'function') {
              taskItem.hooks.beforeEnd(taskItem);
            }
            taskItem.resolve(result);
          })
          .catch(error => {
            if (taskItem.hooks && typeof taskItem.hooks.onError === 'function') {
              taskItem.hooks.onError(taskItem);
            }
            taskItem.reject(error);
          })
          .finally(() => {
            // 处理下一个任务
            setTimeout(() => this._processNext(), 0);
          });
      },
      
      then(callback) {
        if (typeof callback === 'function') {
          this.callbacks.push(callback);
        }
      },
      
      _executeCallbacks() {
        this.callbacks.forEach(callback => {
          try {
            callback();
          } catch (e) {
            console.error('[ErrorLogger] 队列回调执行失败:', e);
          }
        });
      }
    };
    
    // 标记队列为就绪状态
    this.queueReady = true;
    this.pendingInitQueue = false;
  }
  
  /**
   * 初始化日志系统
   * @private
   */
  _init() {
    // 获取设备信息
    this._initDeviceInfo();
    
    // 设置APP生命周期监听
    this._setupAppLifecycleListeners();
    
    // 设置网络状态监听
    this._setupNetworkListener();
    
    // 从本地存储加载未上传的日志
    this._loadLogsFromStorage();
    
    // 设置全局错误处理器
    this._setupGlobalErrorHandlers();
    
    // 如果有网络并且有缓存的日志，尝试上传
    if (this.isConnected && this.logCache.length > 0) {
      // 延迟一段时间再上传，避免应用启动时的网络争用
      setTimeout(() => {
        this._uploadLogs();
      }, 5000);
    }
    
    console.log('[ErrorLogger] 初始化完成');
  }
  
  /**
   * 初始化设备信息
   * @private
   */
  _initDeviceInfo() {
    try {
      const systemInfo = wx.getSystemInfoSync();
      
      this.deviceInfo = {
        platform: systemInfo.platform,
        model: systemInfo.model,
        system: systemInfo.system,
        brand: systemInfo.brand,
        screenWidth: systemInfo.screenWidth,
        screenHeight: systemInfo.screenHeight,
        windowWidth: systemInfo.windowWidth,
        windowHeight: systemInfo.windowHeight,
        pixelRatio: systemInfo.pixelRatio,
        language: systemInfo.language,
        SDKVersion: systemInfo.SDKVersion
      };
      
      console.log('[ErrorLogger] 设备信息初始化完成');
    } catch (e) {
      console.error('[ErrorLogger] 获取设备信息失败:', e);
      this.deviceInfo = { platform: 'unknown' };
    }
  }

  /**
   * 初始化网络状态
   * @private
   */
  _initNetworkStatus() {
    try {
      wx.getNetworkType({
        success: res => {
          this.isConnected = res.networkType !== 'none';
          this.networkType = res.networkType;
          console.log(`[ErrorLogger] 网络状态: ${this.isConnected ? '已连接' : '未连接'} (${res.networkType})`);
        },
        fail: err => {
          console.error('[ErrorLogger] 获取网络状态失败:', err);
          this.isConnected = false;
          this.networkType = 'unknown';
        }
      });
    } catch (e) {
      console.error('[ErrorLogger] 初始化网络状态监听失败:', e);
      this.isConnected = false;
      this.networkType = 'unknown';
    }
  }

  /**
   * 设置全局错误处理器
   * @private
   */
  _setupGlobalErrorHandlers() {
    try {
      // 1. 全局未捕获的JS错误
      wx.onError(error => {
        console.log('[ErrorLogger] 捕获到全局JS错误');
        this.log(error, { 
          category: 'js', 
          level: 'error',
          extra: { source: 'global' }
        });
      });
      
      // 2. 全局未捕获的Promise拒绝
      wx.onUnhandledRejection(res => {
        console.log('[ErrorLogger] 捕获到未处理的Promise拒绝');
        this.log(res.reason || '未处理的Promise拒绝', {
          category: 'promise',
          level: 'error',
          extra: { source: 'unhandledRejection' }
        });
      });
      
      // 3. 页面不存在
      wx.onPageNotFound(res => {
        console.log('[ErrorLogger] 捕获到页面不存在错误');
        this.log('页面不存在', {
          category: 'navigation',
          level: 'warn',
          extra: { 
            path: res.path,
            query: res.query,
            isEntryPage: res.isEntryPage 
          }
        });
      });
      
      // 4. App级别错误处理
      try {
        const app = getApp();
        if (app) {
          const originalOnError = app.onError;
          
          app.onError = err => {
            this.log(err, {
              category: 'app',
              level: 'error',
              extra: { source: 'appOnError' }
            });
            
            if (typeof originalOnError === 'function') {
              originalOnError.call(app, err);
            }
          };
        }
      } catch (e) {
        console.error('[ErrorLogger] 设置App错误处理器失败:', e);
      }
      
      // 5. 拦截原生网络请求
      try {
        const originalRequest = wx.request;
        wx.request = options => {
          const originalFail = options.fail;
          
          options.fail = err => {
            // 记录网络错误
            this.log(err, {
              category: 'network',
              level: 'error',
              extra: { 
                url: options.url,
                method: options.method || 'GET',
                statusCode: err.statusCode
              }
            });
            
            if (typeof originalFail === 'function') {
              originalFail(err);
            }
          };
          
          return originalRequest(options);
        };
      } catch (e) {
        console.error('[ErrorLogger] 拦截网络请求失败:', e);
      }
      
      console.log('[ErrorLogger] 全局错误处理器设置完成');
    } catch (e) {
      console.error('[ErrorLogger] 设置全局错误处理器失败:', e);
    }
  }
  
  /**
   * 启动所有定时任务
   * @private
   */
  _startTimers() {
    // 错开定时任务的启动时间，避免同时执行多个任务
    setTimeout(() => this._startFlushTimer(), 100);
    setTimeout(() => this._startCleanupTimer(), 500);
    setTimeout(() => {
      if (this.config.enableMemoryMonitor) {
        this._startMemoryMonitor();
      }
    }, 1000);
    setTimeout(() => this._startStorageCheckTimer(), 1500);
    
    // 设置应用生命周期监听
    setTimeout(() => this._setupAppLifecycleListeners(), 200);
  }
  
  /**
   * 清理所有定时器
   * @private
   */
  _clearAllTimers() {
    Object.keys(this.timers).forEach(key => {
      if (this.timers[key]) {
        clearTimeout(this.timers[key]);
        clearInterval(this.timers[key]);
        this.timers[key] = null;
      }
    });
  }
  
  /**
   * 根据应用状态调整定时器
   * @param {string} state 应用状态：'foreground' 或 'background'
   * @private
   */
  _adjustTimersByAppState(state) {
    if (state === 'background') {
      // 应用进入后台，停止或降低定时器频率
      this._clearAllTimers();
      
      // 在后台仍保持最低限度的日志上传检查
      this.timers.flush = setTimeout(() => {
        this._flushLogs(true); // 强制执行一次上传
      }, 1000);
    } else if (state === 'foreground') {
      // 应用回到前台，重新启动所有定时器
      this._startTimers();
    }
  }
  
  /**
   * 设置应用生命周期监听
   * @private
   */
  _setupAppLifecycleListeners() {
    try {
      console.log('[ErrorLogger] 设置应用生命周期监听');
      
      // 使用微信小程序官方API监听应用生命周期
      if (typeof wx !== 'undefined' && wx.onAppShow && wx.onAppHide) {
        wx.onAppShow(res => {
          console.log('[ErrorLogger] 应用进入前台');
          this.appState = 'foreground';
          this.lastActiveTime = Date.now();
          
          // 应用恢复前台时，如果网络连接，尝试上传缓存的日志
          if (this.isConnected && this.logCache.length > 0) {
            this._checkAndFlushLogs();
          }
        });
        
        wx.onAppHide(res => {
          console.log('[ErrorLogger] 应用进入后台');
          this.appState = 'background';
          
          // 应用进入后台前，尝试上传缓存的日志
          if (this.logCache.length > 0) {
            this._checkAndFlushLogs(true);
          }
        });
        
        console.log('[ErrorLogger] 应用生命周期监听设置完成');
      } else {
        // 获取App实例
        try {
          const app = getApp();
          
          if (app) {
            // 原始的onShow回调
            const originalOnShow = app.onShow;
            
            // 替换为新的onShow
            app.onShow = (...args) => {
              // 标记应用状态为前台
              this.appState = 'foreground';
              console.log('[ErrorLogger] 应用进入前台');
              
              // 检查网络并尝试上传
              this._initNetworkStatus();
              
              // 调用原始onShow
              if (typeof originalOnShow === 'function') {
                originalOnShow.apply(app, args);
              }
            };
            
            // 原始的onHide回调
            const originalOnHide = app.onHide;
            
            // 替换为新的onHide
            app.onHide = (...args) => {
              // 标记应用状态为后台
              this.appState = 'background';
              console.log('[ErrorLogger] 应用进入后台');
              
              // 保存日志到存储
              this._saveLogsToStorage();
              
              // 调用原始onHide
              if (typeof originalOnHide === 'function') {
                originalOnHide.apply(app, args);
              }
            };
            
            console.log('[ErrorLogger] 应用生命周期监听（通过App对象）设置完成');
          } else {
            console.warn('[ErrorLogger] 无法获取应用实例，生命周期监听器设置失败');
          }
        } catch (e) {
          console.error('[ErrorLogger] 设置App生命周期监听失败:', e);
        }
      }
    } catch (e) {
      console.error('[ErrorLogger] 设置应用生命周期监听失败:', e);
    }
  }
  
  /**
   * 启动定时上传任务，使用递归setTimeout代替setInterval，更灵活控制调度
   * @private
   */
  _startFlushTimer() {
    if (this.timers.flush) {
      clearTimeout(this.timers.flush);
      this.timers.flush = null;
    }
    
    if (this._isErrorLogDisabled()) return;
    
    const scheduleNextFlush = () => {
      if (this._isErrorLogDisabled()) return;
      
      // 使用setTimeout代替setInterval，避免任务堆积
      this.timers.flush = setTimeout(() => {
        // 记录开始时间，用于性能监控
        const startTime = Date.now();
        
        // 执行上传检查
        this._checkAndFlushLogs();
        
        // 检查执行时间，如果过长则调整间隔
        const executionTime = Date.now() - startTime;
        const nextInterval = this._calculateNextInterval(executionTime, this.config.flushInterval);
        
        // 安排下一次执行，避免setTimeout嵌套太深
        this.timers.flush = setTimeout(scheduleNextFlush, nextInterval);
      }, this.config.flushInterval);
    };
    
    scheduleNextFlush();
  }
  
  /**
   * 计算下一次执行间隔，根据当前执行时间动态调整
   * @param {number} executionTime 当前执行时间(ms)
   * @param {number} baseInterval 基础间隔时间(ms)
   * @returns {number} 下一次执行间隔(ms)
   * @private
   */
  _calculateNextInterval(executionTime, baseInterval) {
    // 如果执行时间超过间隔的10%，则延长间隔
    if (executionTime > baseInterval * 0.1) {
      return baseInterval + executionTime;
    }
    return baseInterval;
  }
  
  /**
   * 启动内存监控，使用setTimeout递归
   * @private
   */
  _startMemoryMonitor() {
    if (!this.config.enableMemoryMonitor) return;
    
    if (this.timers.memoryMonitor) {
      clearTimeout(this.timers.memoryMonitor);
      this.timers.memoryMonitor = null;
    }
    
    const monitorMemory = () => {
      if (typeof wx.getPerformance === 'function') {
        try {
          const performance = wx.getPerformance();
          const memory = performance.getMemoryStats();
          
          if (memory && memory.jsHeapSizeLimit && memory.usedJSHeapSize) {
            // 计算内存使用率
            const memoryUsageRatio = memory.usedJSHeapSize / memory.jsHeapSizeLimit;
            
            // 如果内存使用率超过70%，进行紧急清理
            if (memoryUsageRatio > 0.7) {
              console.warn('[ErrorLogger] 内存使用率过高，执行紧急清理');
              this._performEmergencyCleanup();
            }
          }
        } catch (e) {
          // 忽略错误，确保不影响正常功能
        }
        
        // 安排下一次执行
        this.timers.memoryMonitor = setTimeout(monitorMemory, this.config.memoryMonitorInterval);
      }
    };
    
    // 启动监控
    monitorMemory();
  }
  
  /**
   * 设置哈希表清理任务，使用setTimeout递归
   * @private
   */
  _setupCleanupTask() {
    if (this.timers.cleanup) {
      clearTimeout(this.timers.cleanup);
      this.timers.cleanup = null;
    }
    
    const cleanupTask = () => {
      try {
        // 检查哈希表大小
        if (this.logHashMap.size > this.config.maxLogHashMapSize) {
          console.log(`[ErrorLogger] 清理日志哈希表，当前大小: ${this.logHashMap.size}`);
          this.logHashMap.clear();
        } else {
          // 清理过期的日志哈希
          const now = Date.now();
          const expireTime = 24 * 3600 * 1000; // 24小时
          
          // 遍历哈希表删除过期项
          for (const [key, value] of this.logHashMap.entries()) {
            if (value.lastTimestamp && (now - value.lastTimestamp > expireTime)) {
              this.logHashMap.delete(key);
            }
          }
        }
      } catch (e) {
        console.error('[ErrorLogger] 清理日志哈希表失败:', e);
      }
      
      // 安排下一次执行
      this.timers.cleanup = setTimeout(cleanupTask, this.config.hashMapCleanInterval);
    };
    
    // 启动清理任务
    cleanupTask();
  }
  
  /**
   * 设置本地存储检查任务，使用setTimeout递归
   * @private
   */
  _setupStorageCheckTask() {
    if (this.timers.storageCheck) {
      clearTimeout(this.timers.storageCheck);
      this.timers.storageCheck = null;
    }
    
    const storageCheckTask = () => {
      try {
        // 执行存储检查的轻量级版本
        // 不要在一次检查中做太多工作
        this._performLightStorageCheck();
      } catch (e) {
        console.error('[ErrorLogger] 存储检查任务失败:', e);
      }
      
      // 安排下一次执行
      this.timers.storageCheck = setTimeout(storageCheckTask, this.config.storageCheckInterval);
    };
    
    // 启动存储检查任务
    storageCheckTask();
  }
  
  /**
   * 执行轻量级存储检查
   * @private
   */
  _performLightStorageCheck() {
    // 检查API是否已恢复
    if (this.apiFailureState.isFailure && 
        Date.now() >= this.apiFailureState.nextRetryTime) {
      
      // 如果网络已连接，尝试上传缓存的日志
      if (this.isConnected) {
        console.log('[ErrorLogger] 尝试恢复API接口连接并上传缓存日志');
        // 只加载一小批日志，避免一次加载过多
        this._trySendCachedLogsLight();
      }
    }
  }
  
  /**
   * 轻量级方式尝试发送缓存的日志
   * @private
   */
  _trySendCachedLogsLight() {
    try {
      // 先检查内存中的缓存
      if (this.logCache.length > 0) {
        // 仅上传少量日志，避免一次处理过多
        const smallBatch = this.logCache.length > 3 ? 
          this.logCache.slice(0, 3) : this.logCache;
          
        if (smallBatch.length > 0) {
          const logData = {
            logs: smallBatch,
            timestamp: Date.now(),
            appInfo: env.appInfo || {},
            device: this._getDeviceInfo(),
            network: this.networkType
          };
          
          this._addToQueue(logData, true);
          
          // 从缓存中移除已处理的日志
          this.logCache = this.logCache.slice(smallBatch.length);
        }
        return;
      }
      
      // 检查是否需要从本地存储加载
      this._checkAndLoadFromStorage(3); // 只加载最多3条日志
    } catch (e) {
      console.error('[ErrorLogger] 轻量发送缓存日志失败:', e);
    }
  }
  
  /**
   * 检查并从本地存储加载指定数量的日志
   * @param {number} count 要加载的日志数量
   * @private
   */
  _checkAndLoadFromStorage(count) {
    const cachedLogs = this._safeGetStorage(this.storageKeys.logs, []);
    
    if (!Array.isArray(cachedLogs) || cachedLogs.length === 0) return;
    
    // 只取指定数量的日志
    const batchSize = Math.min(count, cachedLogs.length);
    const firstBatch = cachedLogs.slice(0, batchSize);
    
    // 更新本地存储
    const remainingLogs = cachedLogs.slice(batchSize);
    this._safeSetStorage(this.storageKeys.logs, remainingLogs);
    
    // 添加到内存缓存
    this.logCache = [...firstBatch, ...this.logCache];
    
    // 如果有日志，立即尝试上传一次
    if (this.logCache.length > 0) {
      this._checkAndFlushLogs(true);
    }
  }
  
  /**
   * 获取设备信息的缓存版本
   * @returns {object} 设备信息对象
   * @private
   */
  _getDeviceInfo() {
    // 缓存设备信息，避免频繁调用系统API
    // 仅在高频调用时使用缓存
    const now = Date.now();
    
    // 如果缓存不存在或过期，则更新缓存
    if (!this._deviceInfoCache || 
        !this._deviceInfoCache.lastUpdate || 
        now - this._deviceInfoCache.lastUpdate > 3600000) { // 1小时刷新
      
      this._deviceInfoCache = {
        platform: 'unknown',
        model: 'unknown',
        system: 'unknown',
        SDKVersion: 'unknown',
        lastUpdate: now
      };
      
      try {
        const sysInfo = wx.getSystemInfoSync();
        this._deviceInfoCache = {
          platform: sysInfo.platform,
          model: sysInfo.model,
          system: sysInfo.system,
          SDKVersion: sysInfo.SDKVersion,
          lastUpdate: now
        };
      } catch (e) {
        console.error('[ErrorLogger] 获取系统信息失败:', e);
      }
    }
    
    // 返回缓存的设备信息（不返回lastUpdate字段）
    return {
      platform: this._deviceInfoCache.platform,
      model: this._deviceInfoCache.model,
      system: this._deviceInfoCache.system,
      SDKVersion: this._deviceInfoCache.SDKVersion
    };
  }
  
  /**
   * 清理缓存数据
   * @private
   */
  _clearCache() {
    // 清理设备信息缓存
    this._deviceInfoCache = null;
  }
  
  /**
   * 释放资源，用于应用关闭或重启时清理
   */
  dispose() {
    // 清理所有定时器
    this._clearAllTimers();
    
    // 尝试上传缓存的日志
    if (this.logCache.length > 0 && !this.apiFailureState.isFailure) {
      this._flushLogs(true);
    }
    
    // 释放内存
    this.logCache = [];
    this.logHashMap.clear();
    
    // 清理内存缓存
    this._clearCache();
    
    // 重置状态
    this.initialized = false;
    this.activityTrackerSetup = false;
    
    console.log('[ErrorLogger] 资源已释放');
  }
  
  /**
   * 加载本地缓存的日志
   * @private
   */
  _loadCachedLogs() {
    const cachedLogs = this._safeGetStorage(this.storageKeys.logs, []);
    
    if (Array.isArray(cachedLogs) && cachedLogs.length > 0) {
      // 确保不超过最大缓存数量
      const logsToAdd = cachedLogs.slice(-this.config.maxCachedLogs);
      this.logCache = [...logsToAdd, ...this.logCache];
      console.log(`[ErrorLogger] 从本地存储加载了 ${logsToAdd.length} 条日志`);
      
      // 清除本地存储
      this._safeSetStorage(this.storageKeys.logs, []);
    }
  }
  
  /**
   * 保存日志到本地存储
   * @param {Array} logs 要保存的日志数组
   * @private
   */
  _saveLogsToStorage(logs) {
    try {
      // 如果没有提供logs参数，使用当前的logCache
      const logsToSave = logs || this.logCache || [];
      
      // 确保logsToSave是数组
      if (!Array.isArray(logsToSave)) {
        console.error('[ErrorLogger] 保存到存储的日志不是数组');
        return;
      }
      
      // 保存到本地存储
      this._safeSetStorage(this.storageKeys.logs, logsToSave);
      
      console.log(`[ErrorLogger] 已保存 ${logsToSave.length} 条日志到本地存储`);
    } catch (error) {
      console.error('[ErrorLogger] 保存日志到存储失败:', error);
      // 错误处理：尝试删减日志数量后再次保存
      if (logs && logs.length > 10) {
        console.warn('[ErrorLogger] 尝试保存减少的日志数量');
        this._saveLogsToStorage(logs.slice(-Math.floor(logs.length / 2)));
      }
    }
  }
  
  /**
   * 加载API接口状态
   * @private
   */
  _loadApiState() {
    const state = this._safeGetStorage(this.storageKeys.state, null);
    
    if (state && state.apiFailureState) {
      this.apiFailureState = {
        ...this.apiFailureState,
        ...state.apiFailureState
      };
      
      // 如果恢复时间已到，重置故障状态
      if (this.apiFailureState.isFailure && 
          Date.now() > this.apiFailureState.nextRetryTime) {
        this._resetApiFailureState();
      }
    }
  }
  
  /**
   * 保存API接口状态
   * @private
   */
  _saveApiState() {
    const state = {
      apiFailureState: this.apiFailureState
    };
    this._safeSetStorage(this.storageKeys.state, state);
  }
  
  /**
   * 记录API接口失败
   * @private
   */
  _recordApiFailure() {
    this.apiFailureState.consecutiveFailures++;
    this.apiFailureState.lastFailureTime = Date.now();
    
    // 检查是否达到故障阈值
    if (this.apiFailureState.consecutiveFailures >= (this.config.apiFailureThreshold || 3)) {
      if (!this.apiFailureState.isFailure) {
        console.warn(`[ErrorLogger] API接口连续 ${this.apiFailureState.consecutiveFailures} 次失败，进入故障状态`);
      }
      
      this.apiFailureState.isFailure = true;
      
      // 计算指数退避时间
      const backoffFactor = Math.min(Math.pow(2, this.apiFailureState.consecutiveFailures - (this.config.apiFailureThreshold || 3)), 10);
      this.apiFailureState.backoffInterval = Math.min(
        (this.config.apiRecoveryCheckInterval || 60) * 1000 * backoffFactor,
        this.apiFailureState.maxBackoffInterval
      );
      
      this.apiFailureState.nextRetryTime = Date.now() + this.apiFailureState.backoffInterval;
      
      // 保存状态
      this._safeSetStorage(this.storageKeys.state, { apiFailureState: this.apiFailureState });
    }
  }
  
  /**
   * 记录API接口成功
   * @private
   */
  _recordApiSuccess() {
    if (this.apiFailureState.isFailure || this.apiFailureState.consecutiveFailures > 0) {
      // 重置故障状态
      this._resetApiFailureState();
      console.log('[ErrorLogger] API接口恢复正常');
    }
  }
  
  /**
   * 重置API故障状态
   * @private
   */
  _resetApiFailureState() {
    this.apiFailureState = {
      isFailure: false,
      consecutiveFailures: 0,
      lastFailureTime: 0,
      backoffInterval: 5000,
      maxBackoffInterval: 1800000,
      nextRetryTime: 0
    };
    
    // 保存状态
    this._safeSetStorage(this.storageKeys.state, { apiFailureState: this.apiFailureState });
  }
  
  /**
   * 检查API接口是否可用
   * @returns {boolean} 如果API接口可用返回true
   * @private
   */
  _isApiAvailable() {
    // 如果不在故障状态，则可用
    if (!this.apiFailureState.isFailure) {
      return true;
    }
    
    // 如果在故障状态，但已经到了重试时间，则尝试可用
    if (Date.now() >= this.apiFailureState.nextRetryTime) {
      return true;
    }
    
    return false;
  }
  
  /**
   * 检查错误日志是否已禁用
   * @returns {boolean} 如果错误日志已禁用，返回true
   * @private
   */
  _isErrorLogDisabled() {
    return !env.enableErrorLog;
  }
  
  /**
   * 设置用户活动跟踪
   * @private
   */
  _setupUserActivityTracker() {
    if (this.activityTrackerSetup) return;
    
    this.activityTrackerSetup = true;
    this.lastActiveTime = Date.now();
    
    try {
      // 使用更可靠的方式跟踪用户活动
      // 由于小程序不同版本API差异，使用更通用的方法
      
      // 监听小程序页面触摸事件
      const touchEventHandler = () => {
        this.lastActiveTime = Date.now();
      };
      
      // 通过全局事件注入方式监听用户活动
      if (wx.$on) {
        wx.$on('userActivity', touchEventHandler);
      }
      
      // 页面生命周期覆盖函数
      const injectPageLifecycles = () => {
        try {
          // 获取当前页面实例
          const pages = getCurrentPages();
          if (!pages || pages.length === 0) return;
          
          const currentPage = pages[pages.length - 1];
          if (!currentPage) return;
          
          // 存储原始的页面生命周期方法
          const originalOnShow = currentPage.onShow;
          const originalOnHide = currentPage.onHide;
          const originalOnUnload = currentPage.onUnload;
          
          // 注入页面显示处理方法
          currentPage.onShow = function(...args) {
            console.log('[ErrorLogger] 页面显示:', currentPage.route);
            touchEventHandler(); // 更新用户活动时间
            
            // 重新注入触摸监听
            injectTouchListeners(currentPage);
            
            // 调用原始方法
            if (typeof originalOnShow === 'function') {
              originalOnShow.apply(this, args);
            }
          };
          
          // 注入页面隐藏处理方法
          currentPage.onHide = function(...args) {
            console.log('[ErrorLogger] 页面隐藏:', currentPage.route);
            
            // 调用原始方法
            if (typeof originalOnHide === 'function') {
              originalOnHide.apply(this, args);
            }
          };
          
          // 注入页面卸载处理方法
          currentPage.onUnload = function(...args) {
            console.log('[ErrorLogger] 页面卸载:', currentPage.route);
            
            // 调用原始方法
            if (typeof originalOnUnload === 'function') {
              originalOnUnload.apply(this, args);
            }
          };
          
          // 立即为当前页面注入触摸监听
          injectTouchListeners(currentPage);
        } catch (e) {
          console.error('[ErrorLogger] 注入页面生命周期监听失败:', e);
        }
      };
      
      // 注入触摸监听
      const injectTouchListeners = (page) => {
        if (!page) return;
        
        try {
          // 保存原始的触摸事件处理函数
          const originalTouchStart = page.onTouchStart;
          const originalTouchMove = page.onTouchMove;
          
          // 重写触摸事件处理函数
          page.onTouchStart = function(...args) {
            touchEventHandler();
            if (typeof originalTouchStart === 'function') {
              originalTouchStart.apply(this, args);
            }
          };
          
          page.onTouchMove = function(...args) {
            touchEventHandler();
            if (typeof originalTouchMove === 'function') {
              originalTouchMove.apply(this, args);
            }
          };
        } catch (e) {
          console.error('[ErrorLogger] 注入页面触摸监听失败:', e);
        }
      };
      
      // 初始注入当前页面
      injectPageLifecycles();
      
      // 监听路由变化（如果有）
      if (wx.$on) {
        // 页面路由变化时，重新注入生命周期方法
        wx.$on('routeChanged', injectPageLifecycles);
        
        // 页面显示时（官方事件），重新注入触摸监听
        wx.$on('onPageShow', () => {
          try {
            const pages = getCurrentPages();
            if (pages && pages.length > 0) {
              const currentPage = pages[pages.length - 1];
              injectTouchListeners(currentPage);
            }
          } catch (e) {
            console.error('[ErrorLogger] 页面显示事件处理失败:', e);
          }
        });
      }
      
      // 监听全局App的显示与隐藏
      if (typeof wx.onAppShow === 'function') {
        wx.onAppShow(() => {
          this.appState = 'foreground';
          touchEventHandler(); // 更新用户活动时间
          if (wx.$emit) {
            wx.$emit('appStateChange', 'foreground');
          }
        });
      }
      
      if (typeof wx.onAppHide === 'function') {
        wx.onAppHide(() => {
          this.appState = 'background';
          // 应用进入后台时立即尝试上传所有日志
          this.flush(true);
          if (wx.$emit) {
            wx.$emit('appStateChange', 'background');
          }
        });
      }
      
      // 设置定时更新，即使没有用户操作也要定期检查
      setInterval(() => {
        // 模拟心跳，确保即使用户不操作，也能定期检查日志上传条件
        this._checkAndFlushLogs();
      }, 60000); // 每分钟检查一次
    } catch (e) {
      console.error('[ErrorLogger] 设置用户活动跟踪失败:', e);
    }
  }
  
  /**
   * 设置网络状态监听
   * @private
   */
  _setupNetworkListener() {
    try {
      // 获取当前网络状态
      this._initNetworkStatus();
      
      // 监听网络状态变化
      wx.onNetworkStatusChange((res) => {
        const previousState = this.isConnected;
        this.isConnected = res.isConnected;
        this.networkType = res.networkType;
        
        console.log(`[ErrorLogger] 网络状态变化: ${previousState ? '已连接' : '未连接'} -> ${this.isConnected ? '已连接' : '未连接'}`);
        console.log(`[ErrorLogger] 网络类型: ${res.networkType}`);
        
        // 如果网络从断开变为连接，并且有缓存的日志，尝试上传
        if (!previousState && this.isConnected && this.logCache.length > 0 && !this.isUploading) {
          console.log('[ErrorLogger] 网络恢复连接，尝试上传缓存的日志');
          // 重置上传失败计数
          this.uploadFailCount = 0;
          // 延迟一段时间再上传，确保网络稳定
          setTimeout(() => {
            this._checkAndFlushLogs();
          }, 3000);
        }
      });
      
      console.log('[ErrorLogger] 网络状态监听设置完成');
    } catch (e) {
      console.error('[ErrorLogger] 设置网络状态监听失败:', e);
    }
  }
  
  /**
   * 规范化错误对象
   * @param {Error|Object|String} error 错误对象
   * @returns {Object} 标准化后的错误对象
   * @private
   */
  _normalizeError(error) {
    try {
      // 如果是字符串，转换为对象
      if (typeof error === 'string') {
        return {
          name: 'StringError',
          message: error.slice(0, 1000), // 限制长度
          stack: ''
        };
      }
      
      // 如果是标准Error对象
      if (error instanceof Error) {
        return {
          name: error.name || 'Error',
          message: (error.message || '未知错误').slice(0, 1000),
          stack: error.stack || '',
          code: error.code
        };
      }
      
      // 如果是对象
      if (typeof error === 'object' && error !== null) {
        // 针对微信小程序的错误对象处理
        if (error.errMsg) {
          return {
            name: 'WxError',
            message: error.errMsg.slice(0, 1000),
            stack: '',
            code: error.errCode,
            wxError: true,
            detail: JSON.stringify(error).slice(0, 2000)
          };
        }
        
        // 一般对象处理
        return {
          name: error.name || 'ObjectError',
          message: (error.message || JSON.stringify(error).slice(0, 1000)),
          stack: error.stack || '',
          code: error.code,
          detail: JSON.stringify(error).slice(0, 2000)
        };
      }
      
      // 默认情况
      return {
        name: 'UnknownError',
        message: '未能识别的错误类型: ' + String(error).slice(0, 1000),
        stack: ''
      };
    } catch (e) {
      console.error('[ErrorLogger] 规范化错误对象失败:', e);
      return {
        name: 'NormalizeError',
        message: '错误对象规范化失败',
        stack: ''
      };
    }
  }

  /**
   * 判断是否应该限流
   * @private
   * @returns {boolean} 是否应该限流
   */
  _shouldRateLimit() {
    try {
      const now = Date.now();
      
      // 清理过期的日志时间戳
      this.logTimestamps = this.logTimestamps.filter(
        timestamp => now - timestamp < this.config.rateLimit.timeWindow
      );
      
      // 如果当前窗口内的日志数量超过限制，则进行限流
      if (this.logTimestamps.length >= this.config.rateLimit.maxOccurrences) {
        return true;
      }
      
      // 添加当前时间戳到记录
      this.logTimestamps.push(now);
      return false;
    } catch (e) {
      console.error('[ErrorLogger] 检查限流失败:', e);
      return false; // 默认不限流
    }
  }

  /**
   * 安全执行函数
   * @private
   * @param {Function} fn 要执行的函数
   * @param {Array} args 函数参数
   * @param {*} defaultValue 失败时的默认返回值
   * @returns {*} 函数执行结果或默认值
   */
  _safeExecute(fn, args = [], defaultValue = null) {
    try {
      return fn(...args);
    } catch (e) {
      console.error(`[ErrorLogger] 安全执行函数失败:`, e);
      return defaultValue;
    }
  }

  /**
   * 上传日志到服务器
   * @param {Array} logs 要上传的日志数组
   * @returns {Promise} 上传结果的Promise
   * @private
   */
  _uploadLogs(logs) {
    if (!logs || logs.length === 0) {
      console.log('[ErrorLogger] 没有日志需要上传');
      return Promise.resolve({ success: true, message: '没有日志需要上传' });
    }

    // 标记为上传中
    this.isUploading = true;

    // 准备上传数据
    const data = {
      logs: logs,
      appInfo: this.appInfo || {},
      deviceInfo: this.deviceInfo || {},
      timestamp: Date.now(),
      network: this.networkType || 'unknown'
    };

    console.log(`[ErrorLogger] 开始上传 ${logs.length} 条日志`);

    // 返回Promise
    return uploadErrorLog(data)
      .then(response => {
        console.log('[ErrorLogger] 日志上传成功:', response);
        
        // 重置重试计数
        this.retryCount = 0;
        
        // 记录API成功
        this._recordApiSuccess();
        
        return response;
      })
      .catch(error => {
        console.error('[ErrorLogger] 日志上传失败:', error);
        
        // 记录API失败
        this._recordApiFailure();
        
        // 增加重试计数
        this.retryCount++;
        
        throw error;
      })
      .finally(() => {
        // 标记上传结束
        this.isUploading = false;
      });
  }

  /**
   * 检查并刷新日志到服务器
   * @param {boolean} force 是否强制上传
   * @private
   */
  _checkAndFlushLogs(force = false) {
    // 如果没有日志或正在上传中，不执行操作
    if (this.logCache.length === 0 || this.isUploading) {
      return;
    }

    // 检查网络连接状态
    if (!this.isConnected && !force) {
      console.log('[ErrorLogger] 网络连接不可用，稍后重试上传');
      return;
    }

    // 检查API状态
    if (!this._isApiAvailable() && !force) {
      console.log('[ErrorLogger] API接口处于故障状态，稍后重试上传');
      return;
    }

    // 标记上传状态
    this.isUploading = true;

    // 获取要上传的日志批次
    const maxBatch = this.config.batchSize || 10;
    const logsToUpload = this.logCache.slice(0, Math.min(maxBatch, this.logCache.length));
    
    // 上传日志
    this._uploadLogs(logsToUpload)
      .then(() => {
        // 上传成功处理
        console.log(`[ErrorLogger] 成功上传 ${logsToUpload.length} 条日志`);
        
        // 从缓存中移除已上传的日志
        this.logCache = this.logCache.slice(logsToUpload.length);
        
        // 保存更新后的日志缓存
        this._saveLogsToStorage();
        
        // 重置重试计数
        this.retryCount = 0;
        
        // 如果还有更多日志需要上传，继续上传
        if (this.logCache.length > 0) {
          setTimeout(() => {
            this.isUploading = false;
            this._checkAndFlushLogs();
          }, 500);
        } else {
          this.isUploading = false;
        }
      })
      .catch(error => {
        // 处理上传失败
        console.error('[ErrorLogger] 上传日志失败:', error);
        
        // 增加重试计数
        this.retryCount++;
        
        // 计算重试延迟时间（采用指数退避策略）
        const retryDelay = Math.min(
          this.config.retryDelay * Math.pow(2, this.retryCount - 1),
          30000 // 最大延迟30秒
        );
        
        console.log(`[ErrorLogger] 将在 ${retryDelay}ms 后重试上传`);
        
        // 如果超过最大重试次数，丢弃一部分日志
        if (this.retryCount > this.config.maxRetries && this.logCache.length > 10) {
          const discardCount = Math.floor(this.logCache.length / 2);
          console.warn(`[ErrorLogger] 超过最大重试次数，丢弃 ${discardCount} 条最旧的日志`);
          this.logCache = this.logCache.slice(discardCount);
          this._saveLogsToStorage();
          this.retryCount = 0; // 重置重试计数
        }
        
        // 安排重试
        setTimeout(() => {
          this.isUploading = false;
          this._checkAndFlushLogs();
        }, retryDelay);
      });
  }

  /**
   * 收集设备信息
   * @returns {Object} 设备信息
   * @private
   */
  _collectDeviceInfo() {
    const deviceInfo = {
      platform: typeof wx !== 'undefined' ? 'miniprogram' : (typeof navigator !== 'undefined' ? navigator.platform : 'unknown'),
      userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
      screenWidth: typeof screen !== 'undefined' ? screen.width : 0,
      screenHeight: typeof screen !== 'undefined' ? screen.height : 0,
      pixelRatio: typeof window !== 'undefined' ? window.devicePixelRatio : 1,
      language: typeof navigator !== 'undefined' ? (navigator.language || navigator.userLanguage) : 'unknown',
      timeZone: typeof Intl !== 'undefined' ? Intl.DateTimeFormat().resolvedOptions().timeZone : 'unknown',
      timestamp: Date.now()
    };

    // 小程序环境特殊处理
    if (typeof wx !== 'undefined' && wx.getSystemInfoSync) {
      try {
        const systemInfo = wx.getSystemInfoSync();
        Object.assign(deviceInfo, {
          platform: systemInfo.platform,
          model: systemInfo.model,
          system: systemInfo.system,
          screenWidth: systemInfo.screenWidth,
          screenHeight: systemInfo.screenHeight,
          pixelRatio: systemInfo.pixelRatio,
          language: systemInfo.language,
          SDKVersion: systemInfo.SDKVersion
        });
      } catch (e) {
        console.error('[ErrorLogger] 获取系统信息失败:', e);
      }
    }

    return deviceInfo;
  }

  /**
   * 收集应用信息
   * @returns {Object} 应用信息
   * @private
   */
  _collectAppInfo() {
    const appInfo = {
      version: '1.0.0', // 默认版本号
      buildNumber: '1',
      environment: 'development', // 默认使用development环境，避免使用process.env
      sessionId: this._generateSessionId(),
      launchTime: Date.now()
    };

    // 小程序环境特殊处理
    if (typeof wx !== 'undefined' && wx.getAccountInfoSync) {
      try {
        const accountInfo = wx.getAccountInfoSync();
        if (accountInfo && accountInfo.miniProgram) {
          appInfo.version = accountInfo.miniProgram.version || '1.0.0';
          appInfo.appId = accountInfo.miniProgram.appId;
        }
      } catch (e) {
        console.error('[ErrorLogger] 获取小程序账号信息失败:', e);
      }
    }

    return appInfo;
  }

  /**
   * 生成会话ID
   * @returns {string} 会话ID
   * @private
   */
  _generateSessionId() {
    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }

  /**
   * 更新错误日志配置
   * @param {Object} newConfig 新配置
   * @param {Object} [queueInstance] 可选的新队列实例，必须实现QueueInterface接口
   */
  updateConfig(newConfig, queueInstance = null) {
    // 更新配置
    this.config = Object.assign({}, this.config, newConfig);
    
    // 如果提供了新的队列实例，替换当前队列
    if (queueInstance) {
      // 如果旧队列还有任务未完成，先尝试完成
      if (this.queue && !this.queue.isEmpty()) {
        console.log('[ErrorLogger] 队列替换前先完成旧队列任务');
        this.queue.then(() => {
          console.log('[ErrorLogger] 旧队列任务已全部完成');
        });
        this.queue.start();
      }
      
      // 替换队列
      this.queue = queueInstance;
      console.log('[ErrorLogger] 队列实例已更新');
    }
    
    console.log('[ErrorLogger] 配置已更新');
    
    return this;
  }

  /**
   * 从本地存储加载日志
   * @private
   */
  _loadLogsFromStorage() {
    let logs = [];
    
    try {
      if (typeof wx !== 'undefined') {
        // 微信小程序环境
        const logsStr = wx.getStorageSync(this.storageKeys.logs);
        if (logsStr) {
          logs = JSON.parse(logsStr);
        }
      } else if (typeof localStorage !== 'undefined') {
        // 浏览器环境
        const logsStr = localStorage.getItem(this.storageKeys.logs);
        if (logsStr) {
          logs = JSON.parse(logsStr);
        }
      }
      
      // 确保logs是数组
      if (!Array.isArray(logs)) {
        console.warn('[ErrorLogger] 存储中的日志格式不正确，已重置');
        logs = [];
        this._saveLogsToStorage(logs);
      }
    } catch (error) {
      console.error('[ErrorLogger] 加载日志失败', error);
      // 如果加载失败，清空缓存
      logs = [];
      this._saveLogsToStorage(logs);
    }
    
    // 加载日志到内存缓存
    if (logs.length > 0) {
      this.logCache = [...logs, ...this.logCache];
      console.log(`[ErrorLogger] 从本地存储加载了 ${logs.length} 条日志`);
      
      // 清除本地存储中的日志
      this._safeSetStorage(this.storageKeys.logs, []);
    }
  }

  /**
   * 安全操作存储
   * @private
   * @param {string} key 存储键
   * @param {any} value 存储值
   */
  _safeSetStorage(key, value) {
    try {
      const valueStr = JSON.stringify(value);
      if (typeof wx !== 'undefined' && wx.setStorageSync) {
        wx.setStorageSync(key, valueStr);
      } else if (typeof localStorage !== 'undefined') {
        localStorage.setItem(key, valueStr);
      }
    } catch (e) {
      console.error(`[ErrorLogger] 存储写入失败: ${key}`, e);
    }
  }
  
  /**
   * 安全读取存储
   * @private
   * @param {string} key 存储键
   * @param {any} defaultValue 默认值
   * @returns {any} 存储值或默认值
   */
  _safeGetStorage(key, defaultValue) {
    try {
      let valueStr = null;
      if (typeof wx !== 'undefined' && wx.getStorageSync) {
        valueStr = wx.getStorageSync(key);
      } else if (typeof localStorage !== 'undefined') {
        valueStr = localStorage.getItem(key);
      }
      
      if (valueStr) {
        return JSON.parse(valueStr);
      }
    } catch (e) {
      console.error(`[ErrorLogger] 存储读取失败: ${key}`, e);
    }
    
    return defaultValue;
  }

  /**
   * 设置应用程序信息
   * @param {Object} info 应用程序信息
   */
  setAppInfo(info) {
    this.appInfo = Object.assign({}, this.appInfo, info);
  }

  /**
   * 设置用户信息
   * @param {Object} info 用户信息
   */
  setUserInfo(info) {
    this.userInfo = Object.assign({}, this.userInfo, info);
  }

  /**
   * 手动触发日志上传
   * @param {boolean} force 是否强制上传，忽略限制条件
   * @returns {boolean} 是否开始上传
   */
  flush(force = false) {
    if (this.logCache.length === 0) {
      console.log('[ErrorLogger] 没有日志需要上传');
      return false;
    }
    
    if (!this.isConnected && !force) {
      console.log('[ErrorLogger] 当前无网络连接，无法上传');
      return false;
    }
    
    if (this.isUploading && !force) {
      console.log('[ErrorLogger] 已有上传任务正在进行');
      return false;
    }
    
    console.log('[ErrorLogger] 手动触发日志上传');
    
    // 使用队列机制处理上传
    if (force) {
      // 强制刷新队列中所有任务
      this._uploadLogs(this.logCache.slice());
      return true;
    } else {
      // 开始执行队列任务
      if (!this.queue.locked) {
        this.queue.start();
        return true;
      } else {
        console.log('[ErrorLogger] 队列处于锁定状态，等待当前任务完成');
        return false;
      }
    }
  }

  /**
   * 清除日志缓存
   */
  clearLogs() {
    console.log('[ErrorLogger] 清除日志缓存');
    this.logCache = [];
    this._safeSetStorage(this.storageKeys.logs, []);
  }

  /**
   * 获取当前日志数量
   * @returns {number} 缓存的日志数量
   */
  getLogCount() {
    return this.logCache.length;
  }

  /**
   * 记录错误信息
   * @param {Error|Object|String} error - 错误对象、错误信息对象或错误字符串
   * @param {Object} [options] - 附加选项
   * @param {String} [options.level='error'] - 日志级别 (debug, info, warn, error, fatal)
   * @param {String} [options.category='app'] - 错误类别 (app, network, api, ui, etc.)
   * @param {Object} [options.extra={}] - 附加信息
   * @param {Boolean} [options.immediate=false] - 是否立即上传，不缓存
   */
  log(error, options = {}) {
    // 如果错误日志功能被禁用，不执行记录
    if (this._isErrorLogDisabled()) {
      return;
    }
    
    // 应用限流逻辑
    if (this._shouldRateLimit()) {
      console.log('[ErrorLogger] 触发限流，忽略日志');
      return;
    }
    
    try {
      // 标准化错误对象
      const normalizedError = this._normalizeError(error);
      
      // 默认选项
      const defaultOptions = {
        level: 'error',
        category: 'app',
        extra: {},
        immediate: false
      };
      
      // 合并选项
      const mergedOptions = Object.assign({}, defaultOptions, options);
      
      // 创建日志条目
      const logEntry = {
        timestamp: Date.now(),
        level: mergedOptions.level,
        category: mergedOptions.category,
        error: normalizedError,
        extra: mergedOptions.extra,
        // 页面信息
        page: this._getCurrentPage(),
        // 用户行为轨迹
        actions: this._getRecentActions()
      };
      
      console.log(`[ErrorLogger] 记录${mergedOptions.level}级别日志: ${normalizedError.message}`);
      
      // 添加到队列
      this._addToQueue(logEntry, mergedOptions.immediate);
      
      // 如果队列未就绪，则仅缓存日志，不进行上传
      if (!this.queueReady) {
        return;
      }
      
      // 如果设置为立即上传且网络连接可用但队列为空
      if (mergedOptions.immediate && this.isConnected && !this.isUploading && this.queue.isEmpty()) {
        this._uploadLogs([logEntry]);
      } 
      // 否则，如果是严重错误，且网络连接可用，安排延迟上传
      else if (this.isConnected && !this.isUploading && 
              (mergedOptions.level === 'fatal' || mergedOptions.level === 'error')) {
        // 对于严重错误，稍微延迟后上传，允许可能同时发生的其他错误一起打包
        setTimeout(() => {
          this._checkAndFlushLogs();
        }, 1000);
      }
    } catch (e) {
      console.error('[ErrorLogger] 记录日志时出错:', e);
    }
  }

  /**
   * 获取当前页面路径
   * @private
   * @returns {Object} 当前页面信息
   */
  _getCurrentPage() {
    try {
      const pages = getCurrentPages();
      if (pages.length > 0) {
        const currentPage = pages[pages.length - 1];
        return {
          route: currentPage.route,
          options: currentPage.options || {}
        };
      }
    } catch (error) {
      console.error('[ErrorLogger] 获取当前页面失败:', error);
    }
    return { route: 'unknown', options: {} };
  }

  /**
   * 获取近期用户操作
   * @private
   * @returns {Array} 近期用户操作列表
   */
  _getRecentActions() {
    // 实现方式取决于如何跟踪用户操作
    // 这里返回一个空数组作为占位符
    return [];
  }

  /**
   * 将错误添加到上传队列
   * @param {Object} log 错误日志对象
   * @param {boolean} [immediate=false] 是否立即执行
   * @private
   */
  _addToQueue(log, immediate = false) {
    // 如果队列已满，移除最旧的日志
    if (this.logCache.length >= this.config.maxLogCount) {
      this.logCache.shift();
    }
    
    // 添加日志到队列
    this.logCache.push(log);
    
    // 增加会话日志计数
    this.sessionLogCount++;
    
    // 更新本地存储
    this._saveLogsToStorage();
    
    // 如果队列尚未准备好，仅缓存日志
    if (!this.queueReady) {
      console.log('[ErrorLogger] 队列尚未准备好，日志已缓存');
      return;
    }
    
    // 确保队列已初始化
    if (!this.queue) {
      console.error('[ErrorLogger] 队列对象不存在，但状态为就绪');
      this._createFallbackQueue();
    }
    
    // 添加上传任务到队列
    const uploadTask = () => {
      return this._uploadLogs([log]);
    };
    
    try {
      this.queue.addTask(uploadTask, {}, {
        onError: (ctx) => {
          console.error('[ErrorLogger] 队列任务执行失败:', ctx);
        }
      });
      
      // 如果要求立即执行或队列长度达到批处理阈值，立即启动队列
      if (immediate || this.logCache.length >= this.config.batchSize) {
        if (!this.queue.locked) {
          this.queue.start();
        }
      }
      
      // 检查是否需要立即上传
      if (this.logCache.length >= this.config.batchSize) {
        this._checkAndFlushLogs();
      }
    } catch (e) {
      console.error('[ErrorLogger] 添加任务到队列失败:', e);
    }
  }
}

// 创建单例
const errorLogger = new ErrorLogger();

// 监听错误日志开关变化
if (wx.$on) {
  wx.$on('setErrorLogEnabled', (enabled) => {
    if (errorLogger.timers.flush) {
      clearTimeout(errorLogger.timers.flush);
      errorLogger.timers.flush = null;
    }
    
    if (enabled) {
      errorLogger._startTimers();
    }
  });
  
  // 监听应用卸载事件
  wx.$on('appUnload', () => {
    // 应用卸载时释放资源
    errorLogger.dispose();
  });
}

// 监听应用生命周期
if (wx.$on) {
  wx.$on('onAppShow', () => {
    if (wx.$emit) {
      wx.$emit('appStateChange', 'foreground');
    }
  });
  
  wx.$on('onAppHide', () => {
    // 应用进入后台时立即尝试上传所有日志
    errorLogger.flush(true);
    if (wx.$emit) {
      wx.$emit('appStateChange', 'background');
    }
  });
}

/**
 * 记录错误日志
 * @param {Object} options 错误日志选项
 * @param {String} options.type 错误类型: js, api, network, etc.
 * @param {Any} options.error 错误对象
 * @param {String} options.message 错误消息
 * @param {String} options.source 错误来源: global, component, page, etc.
 * @param {Object} options.context 错误上下文
 */
export const log = (options) => errorLogger.log(options);

/**
 * 手动上传所有缓存的日志
 * @param {boolean} force 是否强制上传，忽略限制条件
 */
export const flush = (force = false) => errorLogger.flush(force);

/**
 * 更新错误日志配置
 * @param {Object} newConfig 新配置
 * @param {Object} [queueInstance] 可选的自定义队列实例，必须实现QueueInterface接口
 */
export const updateConfig = (newConfig, queueInstance = null) => 
  errorLogger.updateConfig(newConfig, queueInstance);

/**
 * 设置自定义队列实现
 * @param {Object} queueInstance 自定义队列实例，必须实现QueueInterface接口
 */
export const setQueueImplementation = (queueInstance) => {
  if (!queueInstance) {
    console.error('[ErrorLogger] 设置队列失败：队列实例不能为空');
    return errorLogger;
  }
  
  return errorLogger.updateConfig({}, queueInstance);
};

/**
 * 清除所有日志缓存
 */
export const clearLogs = () => {
  errorLogger.clearLogs();
};

export default {
  log,
  flush,
  updateConfig,
  clearLogs,
  setQueueImplementation
}; 